ViewPager i fragmenty-jaki jest właściwy sposób przechowywania stanu fragmentu?

Chcę zaoferować rozwiązanie, które rozszerza się na antonyt's wspaniała odpowiedź i wspomnieć o nadpisaniu FragmentPageAdapter.instantiateItem(View, int), Aby zapisać odniesienia do utworzonych Fragments, abyś mógł pracować nad nimi później. Powinno to również działać z FragmentStatePagerAdapter; Zobacz uwagi po szczegóły.

Oto prosty przykład, jak uzyskać odniesienie do Fragments zwracanego przez FragmentPagerAdapter, które nie opiera się na wewnętrznym tags ustawionym na Fragments. Kluczem jest nadpisanie instantiateItem() i zapisz referencje w tam zamiast W getItem().

public class SomeActivity extends Activity {
    private FragmentA m1stFragment;
    private FragmentB m2ndFragment;

    // other code in your Activity...

    private class CustomPagerAdapter extends FragmentPagerAdapter {
        // other code in your custom FragmentPagerAdapter...

        public CustomPagerAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public Fragment getItem(int position) {
            // Do NOT try to save references to the Fragments in getItem(),
            // because getItem() is not always called. If the Fragment
            // was already created then it will be retrieved from the FragmentManger
            // and not here (i.e. getItem() won't be called again).
            switch (position) {
                case 0:
                    return new FragmentA();
                case 1:
                    return new FragmentB();
                default:
                    // This should never happen. Always account for each position above
                    return null;
            }
        }

        // Here we can finally safely save a reference to the created
        // Fragment, no matter where it came from (either getItem() or
        // FragmentManger). Simply save the returned Fragment from
        // super.instantiateItem() into an appropriate reference depending
        // on the ViewPager position.
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
            // save the appropriate reference depending on position
            switch (position) {
                case 0:
                    m1stFragment = (FragmentA) createdFragment;
                    break;
                case 1:
                    m2ndFragment = (FragmentB) createdFragment;
                    break;
            }
            return createdFragment;
        }
    }

    public void someMethod() {
        // do work on the referenced Fragments, but first check if they
        // even exist yet, otherwise you'll get an NPE.

        if (m1stFragment != null) {
            // m1stFragment.doWork();
        }

        if (m2ndFragment != null) {
            // m2ndFragment.doSomeWorkToo();
        }
    }
}

Lub jeśli wolisz pracować z tags zamiast zmiennych klasy / odniesień do Fragments Możesz również pobrać tags ustawione przez FragmentPagerAdapter w ten sam sposób: UWAGA: Nie dotyczy to FragmentStatePagerAdapter, ponieważ nie ustawia tags podczas tworzenia swojego Fragments.

@Override
public Object instantiateItem(ViewGroup container, int position) {
    Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
    // get the tags set by FragmentPagerAdapter
    switch (position) {
        case 0:
            String firstTag = createdFragment.getTag();
            break;
        case 1:
            String secondTag = createdFragment.getTag();
            break;
    }
    // ... save the tags somewhere so you can reference them later
    return createdFragment;
}

Zauważ, że ta metoda nie polega na naśladowaniu wewnętrznego tag ustawionego przez FragmentPagerAdapter i zamiast tego używa odpowiednich API do ich pobierania. W ten sposób nawet jeśli tag zmiany w przyszłych wersjach SupportLibrary nadal będziesz bezpieczny.

Nie zapomnij, że w zależności od projektu Activity, Fragments, nad którym próbujesz pracować, może jeszcze istnieć, więc musisz to uwzględnić, wykonując null Kontrole Przed użyciem referencji.

Ponadto, jeśli zamiast pracujesz z FragmentStatePagerAdapter, to nie chcesz zachować twardych odniesień do swojego Fragments, ponieważ możesz mieć ich wiele i twarde odniesienia byłyby niepotrzebnie zachować je w pamięci. Zamiast standardowych zapisywać odwołania Fragment w zmiennych WeakReference. Tak:

WeakReference<Fragment> m1stFragment = new WeakReference<Fragment>(createdFragment);
// ...and access them like so
Fragment firstFragment = m1stFragment.get();
if (firstFragment != null) {
    // reference hasn't been cleared yet; do work...
}

Znalazłem inne stosunkowo łatwe rozwiązanie twojego pytania.

Jak widać z kodu źródłowego FragmentPagerAdapter, fragmenty zarządzane przez FragmentPagerAdapter przechowują się w FragmentManager pod tagiem wygenerowanym przy użyciu:

String tag="android:switcher:" + viewId + ":" + index;

viewId jest container.getId(), container jest twoją ViewPager instancją. index jest pozycją fragmentu. Stąd można zapisać ID obiektu do outState:

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("viewpagerid" , mViewPager.getId() );
}

@Override
    protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);
    if (savedInstanceState != null)
        viewpagerid=savedInstanceState.getInt("viewpagerid", -1 );  

    MyFragmentPagerAdapter titleAdapter = new MyFragmentPagerAdapter (getSupportFragmentManager() , this);        
    mViewPager = (ViewPager) findViewById(R.id.pager);
    if (viewpagerid != -1 ){
        mViewPager.setId(viewpagerid);
    }else{
        viewpagerid=mViewPager.getId();
    }
    mViewPager.setAdapter(titleAdapter);

Jeśli chcesz się komunikować z tym fragmentem, możesz uzyskać if z FragmentManager, np.:

getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewpagerid + ":0")

Chcę zaproponować alternatywne rozwiązanie dla Być może nieco innej sprawy, ponieważ wiele moich poszukiwań odpowiedzi prowadziło mnie do tego wątku.

Moja sprawa - Tworzę / dodaję strony dynamicznie i przesuwam je do Viewpagera, ale po obróceniu (onConfigurationChange) kończę z nową stroną, ponieważ oczywiście OnCreate jest wywoływany ponownie. Ale chcę zachować odniesienia do wszystkich stron, które zostały utworzone przed rotacją.

Problem - I nie mam unikalnych identyfikatorów dla każdego tworzonego przeze mnie fragmentu, więc jedynym sposobem na odwołanie się było przechowywanie referencji w tablicy, która ma zostać przywrócona po zmianie rotacji/konfiguracji.

Workaround - Kluczową koncepcją było, aby aktywność (która wyświetla fragmenty) zarządzała również tablicą odniesień do istniejących fragmentów, ponieważ ta aktywność może wykorzystywać wiązki w onSaveInstanceState {11]}

public class MainActivity extends FragmentActivity

Więc w ramach tej działalności, oświadczam, że członek prywatny do śledź otwarte strony

private List<Fragment> retainedPages = new ArrayList<Fragment>();

@Override
protected void onSaveInstanceState(Bundle outState) {
    retainedPages = _adapter.exportList();
    outState.putSerializable("retainedPages", (Serializable) retainedPages);
    super.onSaveInstanceState(outState);
}

...więc po przechowywaniu można go odzyskać...

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState != null) {
        retainedPages = (List<Fragment>) savedInstanceState.getSerializable("retainedPages");
    }
    _mViewPager = (CustomViewPager) findViewById(R.id.viewPager);
    _adapter = new ViewPagerAdapter(getApplicationContext(), getSupportFragmentManager());
    if (retainedPages.size() > 0) {
        _adapter.importList(retainedPages);
    }
    _mViewPager.setAdapter(_adapter);
    _mViewPager.setCurrentItem(_adapter.getCount()-1);
}

Były to niezbędne zmiany w głównej działalności, więc potrzebowałem członków i metod w moim FragmentPagerAdapter, aby to działało, więc w {11]}

public class ViewPagerAdapter extends FragmentPagerAdapter

Identyczna konstrukcja (jak pokazano powyżej w MainActivity)

private List<Fragment> _pages = new ArrayList<Fragment>();

I to synchronizowanie (jak wyżej w onSaveInstanceState) jest wspierany w szczególności przez metody

public List<Fragment> exportList() {
    return _pages;
}

public void importList(List<Fragment> savedPages) {
    _pages = savedPages;
}

I wreszcie, w klasie fragment

public class CustomFragment extends Fragment

Aby to wszystko zadziałało, nastąpiły dwie zmiany, pierwsza

public class CustomFragment extends Fragment implements Serializable

A następnie dodanie tego do onCreate, aby fragmenty nie zostały zniszczone

setRetainInstance(true);

Wciąż jestem w trakcie owijania głowy wokół fragmentów i cyklu życia Androida, więc zastrzeżenie jest tutaj, że mogą być redundancje/nieefektywności w tej metodzie. Ale to działa dla mnie i ja nadzieja może być pomocna dla innych z przypadkami podobnymi do moich.

Moje rozwiązanie jest bardzo niegrzeczne, ale działa: będąc moimi fragmentami dynamicznie tworzonymi z zachowanych danych, po prostu usuwam cały fragment z PageAdapter przed wywołaniem super.onSaveInstanceState(), a następnie odtwarzam je przy tworzeniu aktywności:

@Override
protected void onSaveInstanceState(Bundle outState) {
    outState.putInt("viewpagerpos", mViewPager.getCurrentItem() );
    mSectionsPagerAdapter.removeAllfragments();
    super.onSaveInstanceState(outState);
}

Nie możesz ich usunąć w onDestroy(), w przeciwnym razie otrzymasz wyjątek:

java.lang.IllegalStateException: nie można wykonać tej czynności po onSaveInstanceState

Tutaj kod w adapterze strony:

public void removeAllfragments()
{
    if ( mFragmentList != null ) {
        for ( Fragment fragment : mFragmentList ) {
            mFm.beginTransaction().remove(fragment).commit();
        }
        mFragmentList.clear();
        notifyDataSetChanged();
    }
}

Zapisuję tylko bieżącą stronę i przywracam ją w onCreate(), po fragmentach zostały stworzone.

if (savedInstanceState != null)
    mViewPager.setCurrentItem( savedInstanceState.getInt("viewpagerpos", 0 ) );  

Co to jest BasePagerAdapter? Powinieneś użyć jednego ze standardowych adapterów pager -- FragmentPagerAdapter lub FragmentStatePagerAdapter, w zależności od tego, czy chcesz, aby fragmenty, które nie są już potrzebne przez ViewPager, były przechowywane w pobliżu (pierwszy) lub aby ich stan został zapisany (drugi) i w razie potrzeby ponownie utworzony.

Przykładowy kod do użycia ViewPager można znaleźć tutaj

To prawda, że zarządzanie fragmentami w pagerze widoku między instancjami aktywności jest trochę skomplikowane, ponieważ FragmentManager w frameworku dba o zapisanie stanu i przywrócenie wszystkich aktywnych fragmentów, które pager wykonał. Wszystko to naprawdę oznacza, że adapter podczas inicjalizacji musi upewnić się, że ponownie łączy się z odtworzonymi fragmentami. Możesz spojrzeć na kod FragmentPagerAdapter lub FragmentStatePagerAdapter, aby zobaczyć, jak to się robi.

Jeśli ktoś ma problemy ze swoim fragmentem Statepageradapter nie przywracając prawidłowo stanu jego fragmentów...tzn....nowe fragmenty są tworzone przez FragmentStatePagerAdapter zamiast przywracać je ze stanu...

Upewnij się, że zadzwonisz ViewPager.setOffscreenPageLimit() zanim zadzwonisz ViewPager.setAdapter(fragmentStatePagerAdapter)

Po wywołaniu ViewPager.setOffscreenPageLimit()...ViewPager natychmiast spojrzy na swój adapter i spróbuje pobrać jego fragmenty. Może się to zdarzyć, zanim ViewPager będzie miał szansę przywrócić fragmenty z savedInstanceState (tworzenie nowych fragmentów, których nie można ponownie zainicjować z SavedInstanceState, ponieważ są nowe).

Wymyśliłam proste i eleganckie rozwiązanie. Zakłada ona, że aktywność jest odpowiedzialna za tworzenie fragmentów, A Adapter po prostu im służy.

To jest kod adaptera (nic dziwnego, poza faktem, że mFragments jest listą fragmentów utrzymywanych przez działanie)

class MyFragmentPagerAdapter extends FragmentStatePagerAdapter {

    public MyFragmentPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return mFragments.get(position);
    }

    @Override
    public int getCount() {
        return mFragments.size();
    }

    @Override
    public int getItemPosition(Object object) {
        return POSITION_NONE;
    }

    @Override
    public CharSequence getPageTitle(int position) {
        TabFragment fragment = (TabFragment)mFragments.get(position);
        return fragment.getTitle();
    }
} 

Cały problem tego wątku polega na uzyskaniu odniesienia do "starych" fragmentów, więc używam tego kodu w aktywności onCreate.

    if (savedInstanceState!=null) {
        if (getSupportFragmentManager().getFragments()!=null) {
            for (Fragment fragment : getSupportFragmentManager().getFragments()) {
                mFragments.add(fragment);
            }
        }
    }

Oczywiście możesz dodatkowo dostroić ten kod w razie potrzeby, na przykład upewniając się, że fragmenty są instancjami danej klasy.

Aby uzyskać fragmenty po zmianie orientacji, musisz użyć .getTag ().

    getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewPagerId + ":" + positionOfItemInViewPager)

Dla nieco większej obsługi napisałem własną ArrayList dla mojej PageAdapter, aby pobrać fragment przez viewPagerId i FragmentClass w dowolnej pozycji:

public class MyPageAdapter extends FragmentPagerAdapter implements Serializable {
private final String logTAG = MyPageAdapter.class.getName() + ".";

private ArrayList<MyPageBuilder> fragmentPages;

public MyPageAdapter(FragmentManager fm, ArrayList<MyPageBuilder> fragments) {
    super(fm);
    fragmentPages = fragments;
}

@Override
public Fragment getItem(int position) {
    return this.fragmentPages.get(position).getFragment();
}

@Override
public CharSequence getPageTitle(int position) {
    return this.fragmentPages.get(position).getPageTitle();
}

@Override
public int getCount() {
    return this.fragmentPages.size();
}


public int getItemPosition(Object object) {
    //benötigt, damit bei notifyDataSetChanged alle Fragemnts refrehsed werden

    Log.d(logTAG, object.getClass().getName());
    return POSITION_NONE;
}

public Fragment getFragment(int position) {
    return getItem(position);
}

public String getTag(int position, int viewPagerId) {
    //getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.shares_detail_activity_viewpager + ":" + myViewPager.getCurrentItem())

    return "android:switcher:" + viewPagerId + ":" + position;
}

public MyPageBuilder getPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
    return new MyPageBuilder(pageTitle, icon, selectedIcon, frag);
}


public static class MyPageBuilder {

    private Fragment fragment;

    public Fragment getFragment() {
        return fragment;
    }

    public void setFragment(Fragment fragment) {
        this.fragment = fragment;
    }

    private String pageTitle;

    public String getPageTitle() {
        return pageTitle;
    }

    public void setPageTitle(String pageTitle) {
        this.pageTitle = pageTitle;
    }

    private int icon;

    public int getIconUnselected() {
        return icon;
    }

    public void setIconUnselected(int iconUnselected) {
        this.icon = iconUnselected;
    }

    private int iconSelected;

    public int getIconSelected() {
        return iconSelected;
    }

    public void setIconSelected(int iconSelected) {
        this.iconSelected = iconSelected;
    }

    public MyPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
        this.pageTitle = pageTitle;
        this.icon = icon;
        this.iconSelected = selectedIcon;
        this.fragment = frag;
    }
}

public static class MyPageArrayList extends ArrayList<MyPageBuilder> {
    private final String logTAG = MyPageArrayList.class.getName() + ".";

    public MyPageBuilder get(Class cls) {
        // Fragment über FragmentClass holen
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return super.get(indexOf(item));
            }
        }
        return null;
    }

    public String getTag(int viewPagerId, Class cls) {
        // Tag des Fragment unabhängig vom State z.B. nach bei Orientation change
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return "android:switcher:" + viewPagerId + ":" + indexOf(item);
            }
        }
        return null;
    }
}

Więc po prostu utwórz MyPageArrayList z fragmentami:

    myFragPages = new MyPageAdapter.MyPageArrayList();

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_data_frag),
            R.drawable.ic_sd_storage_24dp,
            R.drawable.ic_sd_storage_selected_24dp,
            new WidgetDataFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_color_frag),
            R.drawable.ic_color_24dp,
            R.drawable.ic_color_selected_24dp,
            new WidgetColorFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_textsize_frag),
            R.drawable.ic_settings_widget_24dp,
            R.drawable.ic_settings_selected_24dp,
            new WidgetTextSizeFrag()));

I dodaj je do viewpagera:

    mAdapter = new MyPageAdapter(getSupportFragmentManager(), myFragPages);
    myViewPager.setAdapter(mAdapter);

Po tym można uzyskać po zmianie orientacji poprawny fragment za pomocą jego klasy:

        WidgetDataFrag dataFragment = (WidgetDataFrag) getSupportFragmentManager()
            .findFragmentByTag(myFragPages.getTag(myViewPager.getId(), WidgetDataFrag.class));

Nieco inna opinia zamiast samodzielnie przechowywać fragmenty zostaw ją w Fragmentmanagerze, a gdy musisz coś zrobić z fragmentami, poszukaj ich w Fragmentmanagerze:

//make sure you have the right FragmentManager 
//getSupportFragmentManager or getChildFragmentManager depending on what you are using to manage this stack of fragments
List<Fragment> fragments = fragmentManager.getFragments();
if(fragments != null) {
   int count = fragments.size();
   for (int x = 0; x < count; x++) {
       Fragment fragment = fragments.get(x);
       //check if this is the fragment we want, 
       //it may be some other inspection, tag etc.
       if (fragment instanceof MyFragment) {
           //do whatever we need to do with it
       }
   }
}

Jeśli masz dużo fragmentów i koszt instanceof check może nie być tym, czego chcesz, ale dobrze jest mieć na uwadze, że FragmentManager już uwzględnia fragmenty.

Dodaj:

   @SuppressLint("ValidFragment")

To nie działa zrób coś takiego:

@SuppressLint({ "ValidFragment", "HandlerLeak" })